home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / hack / 1 / src / eat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-07-26  |  10.2 KB  |  460 lines
  1. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  2. /* hack.eat.c - version 1.0.3 */
  3.  
  4. #include    "hack.h"
  5. char POISONOUS[] = "ADKSVabhks";
  6. extern char *nomovemsg;
  7. extern int (*afternmv)();
  8. extern int (*occupation)();
  9. extern char *occtxt;
  10. extern struct obj *splitobj(), *addinv();
  11.  
  12. /* hunger texts used on bottom line (each 8 chars long) */
  13. #define    SATIATED    0
  14. #define NOT_HUNGRY    1
  15. #define    HUNGRY        2
  16. #define    WEAK        3
  17. #define    FAINTING    4
  18. #define FAINTED        5
  19. #define STARVED        6
  20.  
  21. char *hu_stat[] = {
  22.     "Satiated",
  23.     "        ",
  24.     "Hungry  ",
  25.     "Weak    ",
  26.     "Fainting",
  27.     "Fainted ",
  28.     "Starved "
  29. };
  30.  
  31. init_uhunger(){
  32.     u.uhunger = 900;
  33.     u.uhs = NOT_HUNGRY;
  34. }
  35.  
  36. #define    TTSZ    SIZE(tintxts)
  37. struct { char *txt; int nut; } tintxts[] = {
  38.     "It contains first quality peaches - what a surprise!",    40,
  39.     "It contains salmon - not bad!",    60,
  40.     "It contains apple juice - perhaps not what you hoped for.", 20,
  41.     "It contains some nondescript substance, tasting awfully.", 500,
  42.     "It contains rotten meat. You vomit.", -50,
  43.     "It turns out to be empty.",    0
  44. };
  45.  
  46. static struct {
  47.     struct obj *tin;
  48.     int usedtime, reqtime;
  49. } tin;
  50.  
  51. opentin(){
  52.     register int r;
  53.  
  54.     if(!carried(tin.tin))        /* perhaps it was stolen? */
  55.         return(0);        /* %% probably we should use tinoid */
  56.     if(tin.usedtime++ >= 50) {
  57.         pline("You give up your attempt to open the tin.");
  58.         return(0);
  59.     }
  60.     if(tin.usedtime < tin.reqtime)
  61.         return(1);        /* still busy */
  62.  
  63.     pline("You succeed in opening the tin.");
  64.     useup(tin.tin);
  65.     r = rn2(2*TTSZ);
  66.     if(r < TTSZ){
  67.         pline(tintxts[r].txt);
  68.         lesshungry(tintxts[r].nut);
  69.         if(r == 1)    /* SALMON */ {
  70.         Glib = rnd(15);
  71.         pline("Eating salmon made your fingers very slippery.");
  72.         }
  73.     } else {
  74.         pline("It contains spinach - this makes you feel like Popeye!");
  75.         lesshungry(600);
  76.         if(u.ustr < 118)
  77.         u.ustr += rnd( ((u.ustr < 17) ? 19 : 118) - u.ustr);
  78.         if(u.ustr > u.ustrmax) u.ustrmax = u.ustr;
  79.         flags.botl = 1;
  80.     }
  81.     return(0);
  82. }
  83.  
  84. Meatdone(){
  85.     u.usym = '@';
  86.     prme();
  87. }
  88.  
  89. doeat(){
  90.     register struct obj *otmp;
  91.     register struct objclass *ftmp;
  92.     register tmp;
  93.  
  94.     /* Is there some food (probably a heavy corpse) here on the ground? */
  95.     if(!Levitation)
  96.     for(otmp = fobj; otmp; otmp = otmp->nobj) {
  97.         if(otmp->ox == u.ux && otmp->oy == u.uy &&
  98.            otmp->olet == FOOD_SYM) {
  99.             pline("There %s %s here; eat %s? [ny] ",
  100.                 (otmp->quan == 1) ? "is" : "are",
  101.                 doname(otmp),
  102.                 (otmp->quan == 1) ? "it" : "one");
  103.             if(readchar() == 'y') {
  104.                 if(otmp->quan != 1)
  105.                     (void) splitobj(otmp, 1);
  106.                 freeobj(otmp);
  107.                 otmp = addinv(otmp);
  108.                 addtobill(otmp);
  109.                 goto gotit;
  110.             }
  111.         }
  112.     }
  113.     otmp = getobj("%", "eat");
  114.     if(!otmp) return(0);
  115. gotit:
  116.     if(otmp->otyp == TIN){
  117.         if(uwep) {
  118.             switch(uwep->otyp) {
  119.             case CAN_OPENER:
  120.                 tmp = 1;
  121.                 break;
  122.             case DAGGER:
  123.             case CRYSKNIFE:
  124.                 tmp = 3;
  125.                 break;
  126.             case PICK_AXE:
  127.             case AXE:
  128.                 tmp = 6;
  129.                 break;
  130.             default:
  131.                 goto no_opener;
  132.             }
  133.             pline("Using your %s you try to open the tin.",
  134.                 aobjnam(uwep, (char *) 0));
  135.         } else {
  136.         no_opener:
  137.             pline("It is not so easy to open this tin.");
  138.             if(Glib) {
  139.                 pline("The tin slips out of your hands.");
  140.                 if(otmp->quan > 1) {
  141.                     register struct obj *obj;
  142.                     extern struct obj *splitobj();
  143.  
  144.                     obj = splitobj(otmp, 1);
  145.                     if(otmp == uwep) setuwep(obj);
  146.                 }
  147.                 dropx(otmp);
  148.                 return(1);
  149.             }
  150.             tmp = 10 + rn2(1 + 500/((int)(u.ulevel + u.ustr)));
  151.         }
  152.         tin.reqtime = tmp;
  153.         tin.usedtime = 0;
  154.         tin.tin = otmp;
  155.         occupation = opentin;
  156.         occtxt = "opening the tin";
  157.         return(1);
  158.     }
  159.     ftmp = &objects[otmp->otyp];
  160.     multi = -ftmp->oc_delay;
  161.     if(otmp->otyp >= CORPSE && eatcorpse(otmp)) goto eatx;
  162.     if(!rn2(7) && otmp->otyp != FORTUNE_COOKIE) {
  163.         pline("Blecch!  Rotten food!");
  164.         if(!rn2(4)) {
  165.             pline("You feel rather light headed.");
  166.             Confusion += d(2,4);
  167.         } else if(!rn2(4)&& !Blind) {
  168.             pline("Everything suddenly goes dark.");
  169.             Blind = d(2,10);
  170.             seeoff(0);
  171.         } else if(!rn2(3)) {
  172.             if(Blind)
  173.               pline("The world spins and you slap against the floor.");
  174.             else
  175.               pline("The world spins and goes dark.");
  176.             nomul(-rnd(10));
  177.             nomovemsg = "You are conscious again.";
  178.         }
  179.         lesshungry(ftmp->nutrition / 4);
  180.     } else {
  181.         if(u.uhunger >= 1500) {
  182.             pline("You choke over your food.");
  183.             pline("You die...");
  184.             killer = ftmp->oc_name;
  185.             done("choked");
  186.         }
  187.         switch(otmp->otyp){
  188.         case FOOD_RATION:
  189.             if(u.uhunger <= 200)
  190.                 pline("That food really hit the spot!");
  191.             else if(u.uhunger <= 700)
  192.                 pline("That satiated your stomach!");
  193.             else {
  194.     pline("You're having a hard time getting all that food down.");
  195.                 multi -= 2;
  196.             }
  197.             lesshungry(ftmp->nutrition);
  198.             if(multi < 0) nomovemsg = "You finished your meal.";
  199.             break;
  200.         case TRIPE_RATION:
  201.             pline("Yak - dog food!");
  202.             more_experienced(1,0);
  203.             flags.botl = 1;
  204.             if(rn2(2)){
  205.                 pline("You vomit.");
  206.                 morehungry(20);
  207.                 if(Sick) {
  208.                     Sick = 0;    /* David Neves */
  209.                     pline("What a relief!");
  210.                 }
  211.             } else    lesshungry(ftmp->nutrition);
  212.             break;
  213.         default:
  214.             if(otmp->otyp >= CORPSE)
  215.             pline("That %s tasted terrible!",ftmp->oc_name);
  216.             else
  217.             pline("That %s was delicious!",ftmp->oc_name);
  218.             lesshungry(ftmp->nutrition);
  219.             if(otmp->otyp == DEAD_LIZARD && (Confusion > 2))
  220.                 Confusion = 2;
  221.             else
  222. #ifdef QUEST
  223.             if(otmp->otyp == CARROT && !Blind){
  224.                 u.uhorizon++;
  225.                 setsee();
  226.                 pline("Your vision improves.");
  227.             } else
  228. #endif QUEST
  229.             if(otmp->otyp == FORTUNE_COOKIE) {
  230.               if(Blind) {
  231.                 pline("This cookie has a scrap of paper inside!");
  232.                 pline("What a pity, that you cannot read it!");
  233.               } else
  234.                 outrumor();
  235.             } else
  236.             if(otmp->otyp == LUMP_OF_ROYAL_JELLY) {
  237.                 /* This stuff seems to be VERY healthy! */
  238.                 if(u.ustrmax < 118) u.ustrmax++;
  239.                 if(u.ustr < u.ustrmax) u.ustr++;
  240.                 u.uhp += rnd(20);
  241.                 if(u.uhp > u.uhpmax) {
  242.                     if(!rn2(17)) u.uhpmax++;
  243.                     u.uhp = u.uhpmax;
  244.                 }
  245.                 heal_legs();
  246.             }
  247.             break;
  248.         }
  249.     }
  250. eatx:
  251.     if(multi<0 && !nomovemsg){
  252.         static char msgbuf[BUFSZ];
  253.         (void) sprintf(msgbuf, "You finished eating the %s.",
  254.                 ftmp->oc_name);
  255.         nomovemsg = msgbuf;
  256.     }
  257.     useup(otmp);
  258.     return(1);
  259. }
  260.  
  261. /* called in hack.main.c */
  262. gethungry(){
  263.     --u.uhunger;
  264.     if(moves % 2) {
  265.         if(Regeneration) u.uhunger--;
  266.         if(Hunger) u.uhunger--;
  267.         /* a3:  if(Hunger & LEFT_RING) u.uhunger--;
  268.             if(Hunger & RIGHT_RING) u.uhunger--;
  269.            etc. */
  270.     }
  271.     if(moves % 20 == 0) {            /* jimt@asgb */
  272.         if(uleft) u.uhunger--;
  273.         if(uright) u.uhunger--;
  274.     }
  275.     newuhs(TRUE);
  276. }
  277.  
  278. /* called after vomiting and after performing feats of magic */
  279. morehungry(num) register num; {
  280.     u.uhunger -= num;
  281.     newuhs(TRUE);
  282. }
  283.  
  284. /* called after eating something (and after drinking fruit juice) */
  285. lesshungry(num) register num; {
  286.     u.uhunger += num;
  287.     newuhs(FALSE);
  288. }
  289.  
  290. unfaint(){
  291.     u.uhs = FAINTING;
  292.     flags.botl = 1;
  293. }
  294.  
  295. newuhs(incr) boolean incr; {
  296.     register int newhs, h = u.uhunger;
  297.  
  298.     newhs = (h > 1000) ? SATIATED :
  299.         (h > 150) ? NOT_HUNGRY :
  300.         (h > 50) ? HUNGRY :
  301.         (h > 0) ? WEAK : FAINTING;
  302.  
  303.     if(newhs == FAINTING) {
  304.         if(u.uhs == FAINTED)
  305.             newhs = FAINTED;
  306.         if(u.uhs <= WEAK || rn2(20-u.uhunger/10) >= 19) {
  307.             if(u.uhs != FAINTED && multi >= 0 /* %% */) {
  308.                 pline("You faint from lack of food.");
  309.                 nomul(-10+(u.uhunger/10));
  310.                 nomovemsg = "You regain consciousness.";
  311.                 afternmv = unfaint;
  312.                 newhs = FAINTED;
  313.             }
  314.         } else
  315.         if(u.uhunger < -(int)(200 + 25*u.ulevel)) {
  316.             u.uhs = STARVED;
  317.             flags.botl = 1;
  318.             bot();
  319.             pline("You die from starvation.");
  320.             done("starved");
  321.         }
  322.     }
  323.  
  324.     if(newhs != u.uhs) {
  325.         if(newhs >= WEAK && u.uhs < WEAK)
  326.             losestr(1);    /* this may kill you -- see below */
  327.         else
  328.         if(newhs < WEAK && u.uhs >= WEAK && u.ustr < u.ustrmax)
  329.             losestr(-1);
  330.         switch(newhs){
  331.         case HUNGRY:
  332.             pline((!incr) ? "You only feel hungry now." :
  333.                   (u.uhunger < 145) ? "You feel hungry." :
  334.                 "You are beginning to feel hungry.");
  335.             break;
  336.         case WEAK:
  337.             pline((!incr) ? "You feel weak now." :
  338.                   (u.uhunger < 45) ? "You feel weak." :
  339.                 "You are beginning to feel weak.");
  340.             break;
  341.         }
  342.         u.uhs = newhs;
  343.         flags.botl = 1;
  344.         if(u.uhp < 1) {
  345.             pline("You die from hunger and exhaustion.");
  346.             killer = "exhaustion";
  347.             done("starved");
  348.         }
  349.     }
  350. }
  351.  
  352. #define    CORPSE_I_TO_C(otyp)    (char) ((otyp >= DEAD_ACID_BLOB)\
  353.              ?  'a' + (otyp - DEAD_ACID_BLOB)\
  354.              :    '@' + (otyp - DEAD_HUMAN))
  355. poisonous(otmp)
  356. register struct obj *otmp;
  357. {
  358.     return(index(POISONOUS, CORPSE_I_TO_C(otmp->otyp)) != 0);
  359. }
  360.  
  361. /* returns 1 if some text was printed */
  362. eatcorpse(otmp) register struct obj *otmp; {
  363. register char let = CORPSE_I_TO_C(otmp->otyp);
  364. register tp = 0;
  365.     if(let != 'a' && moves > otmp->age + 50 + rn2(100)) {
  366.         tp++;
  367.         pline("Ulch -- that meat was tainted!");
  368.         pline("You get very sick.");
  369.         Sick = 10 + rn2(10);
  370.         u.usick_cause = objects[otmp->otyp].oc_name;
  371.     } else if(index(POISONOUS, let) && rn2(5)){
  372.         tp++;
  373.         pline("Ecch -- that must have been poisonous!");
  374.         if(!Poison_resistance){
  375.             losestr(rnd(4));
  376.             losehp(rnd(15), "poisonous corpse");
  377.         } else
  378.             pline("You don't seem affected by the poison.");
  379.     } else if(index("ELNOPQRUuxz", let) && rn2(5)){
  380.         tp++;
  381.         pline("You feel sick.");
  382.         losehp(rnd(8), "cadaver");
  383.     }
  384.     switch(let) {
  385.     case 'L':
  386.     case 'N':
  387.     case 't':
  388.         Teleportation |= INTRINSIC;
  389.         break;
  390.     case 'W':
  391.         pluslvl();
  392.         break;
  393.     case 'n':
  394.         u.uhp = u.uhpmax;
  395.         flags.botl = 1;
  396.         /* fall into next case */
  397.     case '@':
  398.         pline("You cannibal! You will be sorry for this!");
  399.         /* not tp++; */
  400.         /* fall into next case */
  401.     case 'd':
  402.         Aggravate_monster |= INTRINSIC;
  403.         break;
  404.     case 'I':
  405.         if(!Invis) {
  406.             Invis = 50+rn2(100);
  407.             if(!See_invisible)
  408.                 newsym(u.ux, u.uy);
  409.         } else {
  410.             Invis |= INTRINSIC;
  411.             See_invisible |= INTRINSIC;
  412.         }
  413.         /* fall into next case */
  414.     case 'y':
  415. #ifdef QUEST
  416.         u.uhorizon++;
  417. #endif QUEST
  418.         /* fall into next case */
  419.     case 'B':
  420.         Confusion = 50;
  421.         break;
  422.     case 'D':
  423.         Fire_resistance |= INTRINSIC;
  424.         break;
  425.     case 'E':
  426.         Telepat |= INTRINSIC;
  427.         break;
  428.     case 'F':
  429.     case 'Y':
  430.         Cold_resistance |= INTRINSIC;
  431.         break;
  432.     case 'k':
  433.     case 's':
  434.         Poison_resistance |= INTRINSIC;
  435.         break;
  436.     case 'c':
  437.         pline("You turn to stone.");
  438.         killer = "dead cockatrice";
  439.         done("died");
  440.         /* NOTREACHED */
  441.     case 'a':
  442.       if(Stoned) {
  443.           pline("What a pity - you just destroyed a future piece of art!");
  444.           tp++;
  445.           Stoned = 0;
  446.       }
  447.       break;
  448.     case 'M':
  449.       pline("You cannot resist the temptation to mimic a treasure chest.");
  450.       tp++;
  451.       nomul(-30);
  452.       afternmv = Meatdone;
  453.       nomovemsg = "You now again prefer mimicking a human.";
  454.       u.usym = '$';
  455.       prme();
  456.       break;
  457.     }
  458.     return(tp);
  459. }
  460.